﻿using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;
using SixLabors.ImageSharp.Processing;
using SixLabors.ImageSharp.Drawing.Processing;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;

namespace MyWatermark
{
    //public class BlockGenerator
    //{
    //    private const int BASE_BLOCK_SIZE = 64;
    //    private const int OVERLAP_STEP = 16;
    //    private const float TEXTURE_THRESHOLD = 0.65f;

    //    public Dictionary<Point, BlockMetadata> GenerateRedundantBlocks(Image<Bgra32> sourceImage)
    //    {
    //        // 第一阶段：生成基础分块网格
    //        var baseGrid = GenerateBaseGrid(sourceImage);

    //        // 第二阶段：纹理特征分析
    //        var textureMap = BuildTextureMap(sourceImage);

    //        // 第三阶段：动态添加冗余块
    //        var redundantBlocks = AddRedundantBlocks(sourceImage, textureMap);

    //        // 第四阶段：构建空间索引
    //        return BuildSpatialIndex(baseGrid, redundantBlocks);
    //    }

    //    #region 核心子方法实现
    //    private List<BlockMetadata> GenerateBaseGrid(Image<Bgra32> image)
    //    {
    //        var blocks = new List<BlockMetadata>();
    //        int rows = (image.Height - BASE_BLOCK_SIZE) / OVERLAP_STEP + 1;
    //        int cols = (image.Width - BASE_BLOCK_SIZE) / OVERLAP_STEP + 1;

    //        for (int y = 0; y <= image.Height - BASE_BLOCK_SIZE; y += OVERLAP_STEP)
    //        {
    //            for (int x = 0; x <= image.Width - BASE_BLOCK_SIZE; x += OVERLAP_STEP)
    //            {
    //                var rect = new Rectangle(x, y, BASE_BLOCK_SIZE, BASE_BLOCK_SIZE);
    //                blocks.Add(new BlockMetadata
    //                {
    //                    Position = rect,
    //                    IsRedundant = false,
    //                    TextureLevel = 0f
    //                });
    //            }
    //        }
    //        return blocks;
    //    }

    //    private float[,] BuildTextureMap(Image<Bgra32> image)
    //    {
    //        var map = new float[image.Width, image.Height];
    //        int kernelSize = 5;

    //        // 预处理图像数据到内存数组
    //        var luminanceData = PreprocessToLuminanceArray(image);

    //        // 并行计算梯度图（不依赖PixelAccessor）
    //        Parallel.For(0, image.Height, y =>
    //        {
    //            for (int x = 0; x < image.Width; x++)
    //            {
    //                if (IsBorderPixel(x, y, image.Width, image.Height, kernelSize))
    //                {
    //                    map[x, y] = 0;
    //                    continue;
    //                }

    //                // 使用预处理后的数据计算梯度
    //                float gx = CalculateGradientX(luminanceData, x, y);
    //                float gy = CalculateGradientY(luminanceData, x, y);
    //                map[x, y] = MathF.Sqrt(gx * gx + gy * gy);
    //            }
    //        });

    //        NormalizeTextureMap(map);
    //        return map;
    //    }

    //    private List<BlockMetadata> AddRedundantBlocks(Image<Bgra32> image, float[,] textureMap)
    //    {
    //        var redundantBlocks = new List<BlockMetadata>();
    //        int scanStep = BASE_BLOCK_SIZE / 2;

    //        for (int y = 0; y < image.Height - BASE_BLOCK_SIZE; y += scanStep)
    //        {
    //            for (int x = 0; x < image.Width - BASE_BLOCK_SIZE; x += scanStep)
    //            {
    //                float textureSum = 0;
    //                for (int i = 0; i < BASE_BLOCK_SIZE; i++)
    //                    for (int j = 0; j < BASE_BLOCK_SIZE; j++)
    //                        textureSum += textureMap[x + i, y + j];

    //                float textureAvg = textureSum / (BASE_BLOCK_SIZE * BASE_BLOCK_SIZE);

    //                if (textureAvg > TEXTURE_THRESHOLD)
    //                {
    //                    redundantBlocks.Add(new BlockMetadata
    //                    {
    //                        Position = new Rectangle(x, y, BASE_BLOCK_SIZE, BASE_BLOCK_SIZE),
    //                        IsRedundant = true,
    //                        TextureLevel = textureAvg
    //                    });

    //                    // 超高纹理区域添加偏移块
    //                    if (textureAvg > 0.8f)
    //                    {
    //                        redundantBlocks.Add(new BlockMetadata
    //                        {
    //                            Position = new Rectangle(x + 8, y + 8, BASE_BLOCK_SIZE, BASE_BLOCK_SIZE),
    //                            IsRedundant = true,
    //                            TextureLevel = textureAvg
    //                        });
    //                    }
    //                }
    //            }
    //        }
    //        return redundantBlocks;
    //    }
    //    #endregion

    //    #region 辅助方法
    //    private Dictionary<Point, BlockMetadata> BuildSpatialIndex(
    //        List<BlockMetadata> baseBlocks,
    //        List<BlockMetadata> redundantBlocks)
    //    {
    //        return baseBlocks.Concat(redundantBlocks)
    //            .ToDictionary(b =>
    //                new Point(b.Position.X + b.Position.Width / 2,
    //                         b.Position.Y + b.Position.Height / 2));
    //    }

    //    private float Convolve(Span<Bgra32> row, int x, int y,
    //                         float[,] kernel,
    //                         PixelAccessor<Bgra32> accessor)
    //    {
    //        float result = 0;
    //        int radius = kernel.GetLength(0) / 2;

    //        for (int i = -radius; i <= radius; i++)
    //        {
    //            for (int j = -radius; j <= radius; j++)
    //            {
    //                var pixel = accessor.GetRowSpan(y + j)[x + i];
    //                float luminance = 0.299f * pixel.R + 0.587f * pixel.G + 0.114f * pixel.B;
    //                result += luminance * kernel[i + radius, j + radius];
    //            }
    //        }
    //        return result;
    //    }

    //    private void NormalizeTextureMap(float[,] map)
    //    {
    //        float maxVal = 0;
    //        foreach (var val in map)
    //            if (val > maxVal) maxVal = val;

    //        Parallel.For(0, map.GetLength(1), y =>
    //        {
    //            for (int x = 0; x < map.GetLength(0); x++)
    //                map[x, y] /= maxVal;
    //        });
    //    }

    //    private float[,] PreprocessToLuminanceArray(Image<Bgra32> image)
    //    {
    //        var luminance = new float[image.Width, image.Height];

    //        image.ProcessPixelRows(accessor =>
    //        {
    //            for (int y = 0; y < accessor.Height; y++)
    //            {
    //                Span<Bgra32> row = accessor.GetRowSpan(y);
    //                for (int x = 0; x < row.Length; x++)
    //                {
    //                    luminance[x, y] = 0.299f * row[x].R +
    //                                      0.587f * row[x].G +
    //                                      0.114f * row[x].B;
    //                }
    //            }
    //        });
    //        return luminance;
    //    }

    //    private static bool IsBorderPixel(int x, int y, int width, int height, int kernelSize)
    //    {
    //        int radius = kernelSize / 2;
    //        return x < radius || x >= width - radius ||
    //               y < radius || y >= height - radius;
    //    }

    //    private float CalculateGradientX(float[,] luminance, int x, int y)
    //    {
    //        float sum = 0;
    //        for (int i = -1; i <= 1; i++)
    //        {
    //            for (int j = -1; j <= 1; j++)
    //            {
    //                sum += luminance[x + i, y + j] * SobelKernelX[i + 1, j + 1];
    //            }
    //        }
    //        return sum;
    //    }

    //    private float CalculateGradientY(float[,] luminance, int x, int y)
    //    {
    //        float sum = 0;
    //        for (int i = -1; i <= 1; i++)
    //        {
    //            for (int j = -1; j <= 1; j++)
    //            {
    //                sum += luminance[x + i, y + j] * SobelKernelY[i + 1, j + 1];
    //            }
    //        }
    //        return sum;
    //    }
    //    #endregion

    //    #region 内核定义与数据结构
    //    private static readonly float[,] SobelKernelX =
    //    {
    //    { -1, 0, 1 },
    //    { -2, 0, 2 },
    //    { -1, 0, 1 }
    //};

    //    private static readonly float[,] SobelKernelY =
    //    {
    //    { -1, -2, -1 },
    //    {  0,  0,  0 },
    //    {  1,  2,  1 }
    //};

    //    public class BlockMetadata
    //    {
    //        public Rectangle Position { get; set; }
    //        public bool IsRedundant { get; set; }
    //        public float TextureLevel { get; set; }
    //        public List<int> AssociatedBits { get; } = new List<int>();
    //    }
    //    #endregion

    //    #region 可视化方法（ImageSharp实现）
    //    public Image<Bgra32> VisualizeBlocks(Image<Bgra32> image,
    //                                       IEnumerable<BlockMetadata> blocks)
    //    {
    //        var options = new DrawingOptions
    //        {
    //            GraphicsOptions = new GraphicsOptions
    //            {
    //                Antialias = false,
    //                ColorBlendingMode = PixelColorBlendingMode.Normal
    //            }
    //        };

    //        image.Mutate(ctx =>
    //        {
    //            foreach (var block in blocks)
    //            {
    //                var color = block.IsRedundant ? Color.Red : Color.LimeGreen;
    //                ctx.Draw(options, color, 2, block.Position);
    //            }
    //        });

    //        return image;
    //    }
    //    #endregion

    //}
}
